﻿using System;
using System.Linq;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Diagnostics;
//Librerias Arquitectura
using Com.Binaria.Core;
using Com.Binaria.Core.Base;
using Com.Binaria.Core.Dto;
using Com.Binaria.Core.Util;
using Com.Binaria.Core.Datos;
using Com.Binaria.Core.Exceptions;
using Com.Binaria.Core.Enumeracion;
//Librerias Proyecto
using Com.Binaria.SISCOB.Funcional.DTO;
using Com.Binaria.SISCOB.DTO;
using Com.Binaria.SISCOB.DAO;

namespace Com.Binaria.SISCOB.Dom
{
/// <summary>
///	clase de cartolamayor dom
/// </summary>
public partial class CartolaMayorDom : ICartolaMayorDom
{
	#region campos privados
    /// <summary>
    /// Constante que almacena el prefijo de la aplicacion
    /// </summary>
    private const String CLASS_PREFIX = "Com.Binaria.SISCOB.Dom.CartolaMayorDom";
	#endregion
	
    #region campos publicos
        /// <summary>
        /// campo publico que contiene una instancia del objeto (CartolaMayorDAO) encargado del acceso a datos
        /// </summary>
        public ICartolaMayorDAO iCartolaMayorDAO;
    #endregion

    #region constructores
    /// <summary>
    /// constructor por defecto del objeto
    /// </summary>
    public CartolaMayorDom()
    {
		
	}
    #endregion


	
    #region metodos privados
	
	/// <summary>
    /// metodo que permite generar clonaciones de los objetos almacenados en la lista generica 
    /// </summary>
    /// <param name="p_CartolaMayors">lista generica con elementos cartolamayor a copiar</param>
    /// <returns>Objeto view con elementos cartolamayor copiados</returns>
    private List<CartolaMayorDTO> CopiaCartolaMayor(List<CartolaMayorDTO> p_CartolaMayors)
    {
		//Prefijo del Metodo
		const string MPREFIX = " [CopiaCartolaMayor]";
		//Crea lista de objetos de salida
        List<CartolaMayorDTO> RespuestaCopia = new List<CartolaMayorDTO>();		
        try
        {
			//Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
			//Valido que la lista no venga en NULL
            AssertNull.notNullOrEmpty(p_CartolaMayors);
			//Valido que la lista tenga elementos
			AssertNull.notNullOrEmpty(p_CartolaMayors.Count);
			//Recorro la lista de objetos
			foreach (CartolaMayorDTO registro in p_CartolaMayors)
			{
				//Valido que el registro no este vacio
				AssertNull.notNullOrEmpty(registro);
				//Agrega el registro a la lista de respuesta
				RespuestaCopia.Add(registro.Clone());
			}
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de termino del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaCopia;
    }


    /// <summary>
    /// metodo que permite buscar todas los elementos cartolamayor existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
	/// <param name="p_Filtro">Datos para realizar una busqueda por filtros</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private List<CartolaMayorDTO> Buscar(ContextoDTO p_Contexto, CartolaMayorDTO p_Filtro)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
		//Crea lista de objetos de salida
        List<CartolaMayorDTO> RespuestaBuscar = new List<CartolaMayorDTO>();		
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iCartolaMayorDAO.Find(p_Filtro);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }
	
	/// <summary>
	/// metodo que permite buscar el elemento cartolamayor que coincide con el id
	/// </summary>
	/// <param name="p_Contexto">informacion del contexto</param>
	/// <param name="p_IdCartolaMayor">Id de la cartolamayor</param>
	/// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private CartolaMayorDTO Buscar(ContextoDTO p_Contexto, System.Int32? p_IdCartolaMayor)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
        //Crea lista de objetos de salida
        CartolaMayorDTO RespuestaBuscar = new CartolaMayorDTO();
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iCartolaMayorDAO.GetByID((System.Int32)p_IdCartolaMayor);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }

	/// <summary>
	/// metodo que permite buscar todas los elementos cartolamayor existentes
	/// </summary>
	/// <param name="p_Contexto">informacion del contexto</param>
	/// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private List<CartolaMayorDTO> Buscar(ContextoDTO p_Contexto)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
		//Crea lista de objetos de salida
        List<CartolaMayorDTO> RespuestaBuscar = new List<CartolaMayorDTO>();		
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iCartolaMayorDAO.GetAll();
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// metodo al cual se le delega la insercion de elementos de cartolamayor
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_CartolaMayors">elementos de tipo cartolamayor a insertar</param>
    private List<CartolaMayorDTO> InsertarCartolaMayor(ContextoDTO p_Contexto, List<CartolaMayorDTO> p_CartolaMayors)
    {
		//Prefijo del Metodo
        const string MPREFIX = " [InsertarCartolaMayor]";
        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
	
			//Valida que exista informacion a insertar
			AssertNull.notNullOrEmpty(p_CartolaMayors);

			//Crea objeto para almacenar los datos existentes
			List<CartolaMayorDTO> ListaCartolaMayor = new List<CartolaMayorDTO>();

            //try
            //{
                //Obtiene la lista de CartolaMayor
            //    ListaCartolaMayor = Buscar(p_Contexto);
            //}
            //catch (ManagerException me)
            //{
                //Capturo el error cuando no existen datos
            //    if (!me.Message.Substring(0, me.Message.IndexOf(";")).Equals("3001"))
            //    {
            //        throw (me);
            //    }
            //}

	        //Objeto que contiene la cantidad de objetos que existen
            int cant = 0;
            foreach (CartolaMayorDTO CartolaMayor in p_CartolaMayors)
            {
				//Valida que CartolaMayor contenga los datos minimos
						AssertNull.notNullOrEmpty(CartolaMayor);
						AssertNull.notNullOrEmpty(CartolaMayor.IdCuentaCorriente);
						AssertNull.notNullOrEmpty(CartolaMayor.FchEmision);
						AssertNull.notNullOrEmpty(CartolaMayor.FchDesde);
						AssertNull.notNullOrEmpty(CartolaMayor.FchHasta);

				//Busca valores unicos que no se pueden repetir en un registro
	            //cant = ListaCartolaMayor.Where(dto => GetMatchingByUniqueValues(dto, CartolaMayor)).Count();

                //if (!cant.Equals(0))
                //{
                //    break;
                //}
			}

            //Valida que no existan valores unicos
            if (cant.Equals(0))
            {
                //Creo el nuevo registro y almaceno el valor devuelto en el objeto creado
                p_CartolaMayors = iCartolaMayorDAO.Insert(p_CartolaMayors.ToArray()).ToList();
				
				foreach (CartolaMayorDTO CartolaMayor in p_CartolaMayors)
            	{
					//Valido que el valor devuelto corresponda a un indice
					if (CartolaMayor.Id.Equals(0))
					{
						//Registro log de ejecucion con problemas
						Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
						//Genero error debido a que no existen datos a entregar
						throw new ManagerException(Factoria.GetMessage("DOM_ERROR_INSERTAR_BASE"), TraceEventType.Warning);
					}
				}

			}
			else
			{
				//Registro log de ejecucion con problemas
                Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
                //Genero error debido a que no existen datos a entregar
                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_UNICOS_REPETIDOS"), TraceEventType.Warning);
            }

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
		}
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_INSERT"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
		return p_CartolaMayors;
    }
	
    /// <summary>j
    /// metodo al cual se le delega la actualizacion de elementos de cartolamayor
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_CartolaMayors">elementos de tipo cartolamayor a actualizar</param>
    private void ModificarCartolaMayor(ContextoDTO p_Contexto, List<CartolaMayorDTO> p_CartolaMayors)
    {
		//Prefijo del Metodo
		const string MPREFIX = " [ModificarCartolaMayor]";

        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
	
			//Valida que exista informacion a insertar
			AssertNull.notNullOrEmpty(p_CartolaMayors);

			//Crea objeto para almacenar los datos existentes
			//List<CartolaMayorDTO> ListaCartolaMayor = new List<CartolaMayorDTO>();

            //try
            //{
            //    //Obtiene la lista de CartolaMayor
            //    ListaCartolaMayor = Buscar(p_Contexto);
            //}
            //catch (ManagerException me)
            //{
            //    //Administra la estructura de errores por codigo
            //    switch (me.Message.Substring(0, me.Message.IndexOf(";")))
            //    {
            //        case "3001":
            //            throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
            //        default:
            //            throw(me);
            //    }
            //}

	        //Objeto que contiene la cantidad de objetos que existen
            int cant = 0;
            foreach (CartolaMayorDTO CartolaMayor in p_CartolaMayors)
            {
				//Valida que CartolaMayor contenga los datos minimos
						AssertNull.notNullOrEmpty(CartolaMayor);
						AssertNull.notNullOrEmpty(CartolaMayor.IdCuentaCorriente);
						AssertNull.notNullOrEmpty(CartolaMayor.FchEmision);
						AssertNull.notNullOrEmpty(CartolaMayor.FchDesde);
						AssertNull.notNullOrEmpty(CartolaMayor.FchHasta);

				//Busca valores unicos que no sepueden repetir en un registro
	            //cant = ListaCartolaMayor.Where(dto => GetMatchingByUniqueValues(dto, CartolaMayor)).Count();

                if (!cant.Equals(0))
                {
                    break;
                }
				else
				{
					//Creo objeto para recepcionar respuesta de la busqueda
					CartolaMayorDTO CartolaMayorEncontrada = new CartolaMayorDTO();

					try
					{
						//Realizo la busqueda en cache
						CartolaMayorEncontrada = Buscar(p_Contexto, (System.Int32?)CartolaMayor.Id);
                    }
                    catch (ManagerException me)
                    {
                        //Administra la estructura de errores por codigo
                        switch (me.Message.Substring(0, me.Message.IndexOf(";")))
                        {
                            case "3001":
                                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
                        }
                    }
					
					//Verifico si el registro existe en cache
					if (CartolaMayorEncontrada == null)
					{
						//Registro log de ejecucion con problemas
						Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
						//Genero error debido a que no existen datos a entregar
						throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), TraceEventType.Warning);
					}
				}
			}
			
			//Valida que no existan valores unicos
            if (cant.Equals(0))
            {
				//Actualizo la informacion existente
				iCartolaMayorDAO.Update(p_CartolaMayors.ToArray());

			}
			else
			{
				//Registro log de ejecucion con problemas
                Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
                //Genero error debido a que no existen datos a entregar
                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_UNICOS_REPETIDOS"), TraceEventType.Warning);
                //Cambio valor de insertar a falso
            }

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_UPDATE"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
		catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
    }
	
    /// <summary>
    /// metodo al cual se le delega la eliminacion de elementos de tipo cartolamayor
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_CartolaMayors">elementos de tipo cartolamayor a eliminar</param>
    private void EliminarCartolaMayor(ContextoDTO p_Contexto, List<CartolaMayorDTO> p_CartolaMayors)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [EliminarCartolaMayor]";
		
        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
			//Creo Clase para enviar los Id de aviso a eliminar
			List<System.Int32> IdCartolaMayors = new List<System.Int32>();
	        foreach (CartolaMayorDTO CartolaMayor in p_CartolaMayors)
            {
				//Valida que CartolaMayor contenga los datos minimos
				AssertNull.notNullOrEmpty(CartolaMayor);
				AssertNull.notNullOrEmpty(CartolaMayor.Id);

				//Creo objeto para recepcionar respuesta de la busqueda
				CartolaMayorDTO CartolaMayorEncontrada = new CartolaMayorDTO();

				try
				{
					//Realizo la busqueda
					CartolaMayorEncontrada = Buscar(p_Contexto, (System.Int32?)CartolaMayor.Id);
				}
				catch (ManagerException me)
				{
					//Adminstra la estructura de errores por codigo
					switch (me.Message.Substring(0, me.Message.IndexOf(";")))
					{
						case "3001":
							throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
                        default:
                            throw(me);
					}
				}
                //Verifico si el registro existe en cache
				if (CartolaMayorEncontrada != null)
				{
					IdCartolaMayors.Add((System.Int32)CartolaMayor.Id);
				}
            }
			
			if (IdCartolaMayors.Count>0)
			{
				//Elimino los registros
				iCartolaMayorDAO.Delete(IdCartolaMayors.ToArray());
			}

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
		}
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_UPDATE"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
		catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
    }
	
	#region metodos privados estaticos
	/// <summary>
    /// metodo que permite buscar lo elementos de tipo cartolamayor coincidentes en base a sus propiedades que contienen valores unicos
    /// </summary>
    /// <param name="p_CartolaMayor">elemento de tipo cartolamayor a buscar</param>
    /// <param name="p_CartolaMayorComparer">elemento de tipo cartolamayor a comparar</param>
    /// <returns>retorna valor booleano indicando existencia de igualdad</returns>
    private static bool GetMatchingByUniqueValues(CartolaMayorDTO p_CartolaMayor, CartolaMayorDTO p_CartolaMayorComparer)
    {
		//Este metodo valida que la informacion no este repetida
		bool returnValue = false;
		returnValue = 
                (p_CartolaMayor.FchEmision.ToString().ToUpper() == p_CartolaMayorComparer.FchEmision.ToString().ToUpper())
				&&
                (p_CartolaMayor.FchDesde.ToString().ToUpper() == p_CartolaMayorComparer.FchDesde.ToString().ToUpper())
				&&
                (p_CartolaMayor.FchHasta.ToString().ToUpper() == p_CartolaMayorComparer.FchHasta.ToString().ToUpper())
				&&
                (p_CartolaMayor.IdCuentaCorriente.ToString().ToUpper() == p_CartolaMayorComparer.IdCuentaCorriente.ToString().ToUpper())
				&&
                (p_CartolaMayorComparer.Id.Equals(default(System.Int32?)) || p_CartolaMayor.Id != p_CartolaMayorComparer.Id);
		return returnValue;
    }	
	
    /// <summary>
    /// metodo que permite buscar todos los elementos de tipo cartolamayor coincidentes en base a las propiedades del objeto
    /// </summary>
    /// <param name="p_CartolaMayor">elemento de tipo cartolamayor a comparar</param>
    /// <param name="p_Filtro">filtro de elemento de tipo cartolamayor a comparar</param>
    /// <returns>retorna valor booleano indicando existencia de igualdad</returns>
    private static bool FindMatching(CartolaMayorDTO p_CartolaMayor, CartolaMayorDTO p_Filtro)
    {
		bool returnValue = false;

		returnValue =		
                (p_Filtro.Id == null || (p_CartolaMayor.Id == null?null: p_CartolaMayor.Id.ToString().ToUpper()) == p_Filtro.Id.ToString().ToUpper())
				&&
                (p_Filtro.FchEmision == null || (p_CartolaMayor.FchEmision == null?null: p_CartolaMayor.FchEmision.ToString().ToUpper()) == p_Filtro.FchEmision.ToString().ToUpper())
				&&
                (p_Filtro.FchDesde == null || (p_CartolaMayor.FchDesde == null?null: p_CartolaMayor.FchDesde.ToString().ToUpper()) == p_Filtro.FchDesde.ToString().ToUpper())
				&&
                (p_Filtro.FchHasta == null || (p_CartolaMayor.FchHasta == null?null: p_CartolaMayor.FchHasta.ToString().ToUpper()) == p_Filtro.FchHasta.ToString().ToUpper())
				&&
                 (p_Filtro.IdCuentaCorriente == null || (p_CartolaMayor.IdCuentaCorriente == null?null: p_CartolaMayor.IdCuentaCorriente.ToString().ToUpper()) == p_Filtro.IdCuentaCorriente.ToString().ToUpper())										;

		return returnValue;
    }	
	#endregion metodos privados estaticos
	#endregion metodos privados	


	#region metodos publicos

	
	
	#region ICartolaMayorDom Members
	
	/// <summary>
    /// Metodo que permite buscar los elementos de tipo cartolamayor existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public List<CartolaMayorDTO> BuscarCartolaMayorFiltro(ContextoDTO p_Contexto, CartolaMayorDTO p_Filtro)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, CartolaMayorDTO)]";
        //Crea lista de objetos de salida
        List<CartolaMayorDTO> RespuestaBuscar = new List<CartolaMayorDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_Filtro);

			//Obtengo la lista de objetos almacenados en la base de datos
			RespuestaBuscar = Buscar(p_Contexto, p_Filtro);
				
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

	/// <summary>
    /// metodo que permite buscar los elementos de tipo cartolamayor existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_IdCartolaMayor">informacion por el Id de la tabla CartolaMayor</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public CartolaMayorDTO BuscarCartolaMayorPorId(ContextoDTO p_Contexto, System.Int32? p_IdCartolaMayor)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, CartolaMayorDTO)]";
        //Crea lista de objetos de salida
        CartolaMayorDTO RespuestaBuscar = new CartolaMayorDTO();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_IdCartolaMayor);

			//Obtengo la lista de objtos almacenados en la base de datos
			RespuestaBuscar = Buscar(p_Contexto, p_IdCartolaMayor);
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

	/// <summary>
    /// metodo que permite buscar los elementos de tipo cartolamayor existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public List<CartolaMayorDTO> BuscarCartolaMayorTodos(ContextoDTO p_Contexto)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, CartolaMayorDTO)]";
        //Crea lista de objetos de salida
        List<CartolaMayorDTO> RespuestaBuscar = new List<CartolaMayorDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

			//Obtengo la lista de objetos almacenados
			RespuestaBuscar = Buscar(p_Contexto);

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

    /// <summary>
    /// metodo que permite registrar elementos de tipo cartolamayor en el sistema
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_CartolaMayor">cartolamayor a registrar (insertar, actualizar o eliminar)</param>
    /// <param name="p_Accion">Accion a realizar</param>
    public List<CartolaMayorDTO> RegistrarCartolaMayor(ContextoDTO p_Contexto, List<CartolaMayorDTO> p_CartolaMayors, EnumRegistrarAccion p_Accion)
	{
        //Prefijo del Metodo
        const String MPREFIX = " [Registrar]";
		//Resultado accion insertar
		List<CartolaMayorDTO> Resultado_Insertar = new List<CartolaMayorDTO>();
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion en el objeto
            AssertNull.notNullOrEmpty(p_CartolaMayors);
            //Realiza la accion solicitada
            switch (p_Accion)
            {
                case EnumRegistrarAccion.Agregar:
                    Resultado_Insertar = InsertarCartolaMayor(p_Contexto, p_CartolaMayors);
                    break;
                case EnumRegistrarAccion.Modificar:
                    ModificarCartolaMayor(p_Contexto, p_CartolaMayors);
                    break;
                case EnumRegistrarAccion.Eliminar:
                    EliminarCartolaMayor(p_Contexto, p_CartolaMayors);
                    break;
                default:
                    break;
            }
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
		return Resultado_Insertar;
	}	
    #endregion ICartolaMayorDom Members
    #endregion metodos publicos

	}//End class CartolaMayorDom
}//End namespace





